home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1996 January / macformat-033.iso / mac / Shareware City / Developers / VideoToolbox / VideoToolboxSources / CopyBitsQuickly.c < prev    next >
Encoding:
Text File  |  1995-08-13  |  24.2 KB  |  631 lines  |  [TEXT/CWIE]
  1. /*
  2. CopyBitsQuickly.c
  3.  
  4. CopyBitsQuickly.c is a dumb substitute for CopyBits that ignores the color
  5. tables and palettes, simply copying the raw pixels without any translation. It's
  6. for doing animations. (Try the demo Sandstorm.) Besides copying images, it can
  7. also add or multiply them. At one time it copied much faster than CopyBits did,
  8. but the latest timing (under System 7), by TimeVideo, indicates that they are of
  9. approximately equal speed.
  10.  
  11. Apple's CopyBits is an Apple Macintosh Toolbox routine for copying images, and
  12. is documented in Inside Macintosh Volumes I,V, and VI, and New Inside Macintosh:
  13. "Imaging with QuickDraw". CopyBitsQuickly does not cause the Memory Manager to
  14. move memory, and thus may be used in a VBL task.
  15.  
  16. I suggest that you use the higher-level interface provided by
  17. the VideoToolbox CopyWindows.c, which saves you from getting your hands dirty
  18. messing with pixmaps. You can just deal with windows and GWorlds.
  19.  
  20. The returned value is nonzero if an error occurred.
  21.  
  22. CopyBitsQuickly supports four modes:
  23. • srcCopy copies the source to the destination.
  24. • addOver adds the source to the destination. Both must have 8-bit pixels.
  25. Overflow is ignored.
  26. • addOverParallel adds the source to the destination (4 bytes at a time), i.e.
  27. parallel addition. Overflow may carry over into neighboring pixels within the image.
  28. Supports all pixel sizes.
  29. • mulOver causes the source and destination to be multiplied, pixel by pixel. Both
  30. must have 8-bit pixels. After multiplication, the product is divided by 128 and
  31. stored in the destination. Overflow is ignored. All the arithmetic is unsigned.
  32.  
  33. RESTRICTIONS:
  34. • srcBits and dstBits must both have the same number of bits/pixel.
  35. • dstRect and srcRect must have the same size.
  36. • mode must be either srcCopy, addOver, addOverParallel, or mulOver.
  37. • maskRgn must be NULL.
  38. • If mode is addOver or mulOver then the pixel size must be 8 bits.
  39. • If CopyBitsQuickly detects a violation of any of these restrictions it will return
  40. a nonzero value, indicating that an error occured.
  41.  
  42. RETURNED VALUE:
  43. 0 Success.
  44. 1 Illegal srcMode (only srcCopy, addOver, and mulOver are allowed). 
  45. 2 maskRgn!=NULL.
  46. 3 Source and destination rects are of unequal size.
  47. 4 After clipping there were no pixels to copy, or RectToAddress couldn't resolve 
  48.     address of source or destination.
  49. 5 Source and destination have unequal pixel sizes.
  50. 6 We need 32-bit addressing but it's not available.
  51. 7 This mode requires 8-bit pixels and the supplied pixel size is not 8 bits.
  52.  
  53. ACKNOWLEDGEMENTS:
  54. I learned the trick of using a switch() to jump into a loop from Bill Karsh's solution
  55. to the April 1994 MacTech Programmer's Challenge.
  56.  
  57. LIMITATIONS:
  58. • If a Rect extends across multiple screens, only as much of the upper-left of
  59. the Rect that's on one device will be used. The rest is clipped off.
  60. • When accessing a screen, CopyBitsQuickly() ought to, but doesn't, call
  61. ShieldCursor() to remove the cursor from the part of the screen it's reading or
  62. writing. Calling ShieldCursor would also have the desirable side effect of
  63. informing nonstandard video devices, like the Radius PowerView, that the screen
  64. has been updated. (NOTE: CopyWindows does this for you before calling CopyBitsQuickly.)
  65.  
  66. NOTE: For highest speed you should choose your srcRectPtr & dstRectPtr so that
  67. the first point moved to and from each row begins at a memory address that is a
  68. multiple of 4 bytes. The effect on speed is substantial, about 25%.
  69.  
  70. NOTE: If your computer boots in 24-bit mode, as set by the Memory Control Panel,
  71. then the THINK C Debugger will crash if it's activated while you've temporarily
  72. switched into 32-bit mode. So don't put any breakpoints in any section of code
  73. that's bracketed by calls to SwapMMUMode() unless your computer booted up in
  74. 32-bit mode. If your computer boots in 32-bit mode then the calls to SwapMMUMode
  75. do nothing, and you can put Debugger breakpoints anywhere.
  76.  
  77. BLOCKMOVEDATA: NOT FASTER
  78.  
  79. BlockMoveData is a new (as of System Update 3.0 to System 7) variant of
  80. BlockMove that omits cache flushing. Issuing BlockMoveData() on earlier versions
  81. of the operating system will invoke plain old BlockMove(). BlockMoveData, like
  82. BlockMove, uses the MOVE16 instruction, on computers that have it, so it could
  83. potentially be faster than the generic code that most compilers produce.
  84. However, I haven't found any speed advantage on the PowerBook 170, Mac II, IIfx,
  85. and Power Mac in my lab (none of which have the 68040, which is the only cpu
  86. that has MOVE16). I haven't tried it on a Quadra. 
  87.  
  88. To my surprise, BlockMoveData isn't faster than my C loop on the Mac II, IIfx,
  89. or Power Mac 6100/60, and is distinctly slower in a few cases (e.g. 1 bit mode
  90. on Toby card), so I've disabled it. So the following 2 paragraphs are moot.
  91.  
  92. IGNORE: CopyBitsQuickly.c, if possible, now uses Apple's BlockMoveData() for
  93. highest possible speed on all Macs. For best performance you should set your
  94. Memory Control Panel to 32-bit addressing, and you should install Apple's System
  95. Update 3.0, which requires System 7.1, or whatever System release supercedes it.
  96. If your Mac is very old, e.g. a Mac II, you may need to install the freely
  97. available MODE32 init in order to be able to enable 32-bit addressing.
  98.  
  99. IGNORE: I've disabled the use of BlockMoveData if the computer has a 68040
  100. processor, yet is a Mac II. I do this because BlockMoveData crashes on my Radius
  101. Rocket (68040 processor on a NuBus card) in my Mac II when handed addresses in
  102. video memory, even though MODE32 is installed. Presumably this indicates that
  103. the BlockMove routine is not 32-bit clean, despite the runtime patches installed
  104. by MODE32. This is puzzling since BlockMove works fine accessing the same video
  105. addresses in either 24 or 32-bit mode (with MODE32) without the Rocket.
  106.  
  107. Copyright ©1989-1995 Denis G. Pelli.
  108.  
  109. HISTORY:
  110. 1/89 dgp    Version 2.0: added support for PixMaps and multiple screens. Added checking.
  111. 6/89 dgp    Version 3.0: now use RectToAddress, which clips to one device.
  112. 10/89 dgp    Version 3.5: Improved resolution from longs to bytes.
  113. 10/89 dgp    Version 4.0: Added new mode: addOver
  114. 3/90  dgp    Version 4.01: Made cosmetic changes:
  115.             renamed srcRect & dstRect to srcRectPtr and dstRectPtr.
  116.             renamed srcAdd to addOver, to conform to CopyBits.
  117.             added a few more comments to explain the initial clipping.
  118. 3/20/90    dgp    made compatible with MPW C.
  119. 4/20/90    dgp    now uses 32-bit addressing only if QD32 is present.
  120. 4/9/91    dgp    v 4.05: changed nudge from short to long, just to be safe
  121. 8/24/91    dgp    Made compatible with THINK C 5.0.
  122. 4/15/92    dgp    Updated CopyBitsQuickly's function header to Standard C style.
  123. 10/5/92 dgp    Dropped support for THINK C 4. Updated the documentation above.
  124. 12/2/92 dgp cosmetic changes
  125. 12/8/92 dgp fixed major gaffe introduced on 12/2/92: "case" prefix was 
  126.             missing in switch statement. This caused CopyBitsQuickly to do nothing. 
  127. 1/31/93    dgp    Added new "multiplyQuickly" mode requested by Josh Solomon. Now 
  128.             insist on 8-bit pixels for both addOver and multiplyQuickly modes.
  129. 2/18/93    js    added mulOver to list of allowed modes. (Oops! - dgp.) Works ok now.
  130. 2/18/93    dgp    Now return int, nonzero if error occurred.
  131. 7/9/93    dgp check for 32-bit addressing capability.
  132. 6/5/94    dgp Replaced all assembly code by portable C code of similar speed. Only call 
  133.             SwapMMUMode() if we must. Give error if we need 32-bit mode and it's not 
  134.             available. Documented the returned value.
  135. 6/7/94    dgp    Added code to use Apple's BlockMoveData() for highest
  136.             possible speed on all Macs, but disabled it because it didn't turn
  137.             out to be faster on the machines on which I've tested it: Mac II, IIfx,
  138.             and Power Mac 6100/60.
  139. 6/7/94    dgp    Added new mode "addOverParallel" which accepts any pixelSize and adds
  140.             source to destination very quickly by adding 4 bytes at a time.
  141. 6/14/94    dgp    can32 is now computed by calling TrapAvailable(_SwapMMUMode), which 
  142.             returns the correct answer even on Macs with dirty ROMs.
  143. 5/23/95 dgp Apple changed the prototype in the header file from SwapMMUMode(char *) to 
  144.             SwapMMUMode(signed char *). To retain compatibility with both old and new
  145.             headers, I cast the argument (void *).
  146. */
  147. #include "VideoToolbox.h"
  148. void ReadPixels(int x,int y,int n,unsigned long *value
  149.     ,unsigned char *baseAddr,long pixelSize,long rowBytes);
  150. void WritePixels(int x,int y,int n,unsigned long *value
  151.     ,unsigned char *baseAddr,long pixelSize,long rowBytes);
  152. // The srcMode constants addOverParallel and mulOver are defined in VideoToolbox.h
  153. #ifndef __TRAPS__
  154.     #include <Traps.h>        // _SwapMMUMode
  155. #endif
  156. #if (THINK_C || THINK_CPLUS || SYMANTEC_C)
  157.     // These THINK C options seem to have very little effect on the code produced.
  158.     // However, if you don't disable "assign_registers" then one of the variables
  159.     // declared "register" in srcCopyQuickly() fails to be assigned to a register.
  160.     #pragma options(!assign_registers,honor_register,redundant_loads,defer_adjust)
  161.     #pragma options(global_optimizer,gopt_induction,gopt_loop,gopt_cse,gopt_coloring)
  162. #endif
  163.  
  164. typedef unsigned char *UPtr;
  165.  
  166. static void Expand8(double hMag,double vMag,double hOffset,double vOffset
  167.     ,register UPtr Src,Rect *srcRect,unsigned long srcRowBytes
  168.     ,register UPtr Dst,Rect *dstRect,unsigned long dstRowBytes,Boolean do32);
  169. static void Expand(double hMag,double vMag,double hOffset,double vOffset
  170.     ,register UPtr Src,Rect *srcRect,int srcPixelBits,unsigned long srcRowBytes
  171.     ,register UPtr Dst,Rect *dstRect,int dstPixelBits,unsigned long dstRowBytes,Boolean do32);
  172. static void SrcCopyQuickly(UPtr Src,unsigned long srcinc,
  173.     UPtr Dst,unsigned long dstinc,
  174.     unsigned long bytes,unsigned long lines,Boolean do32);
  175. static void SrcCopyQuickly2(UPtr Src,unsigned long srcinc,
  176.     UPtr Dst,unsigned long dstinc,
  177.     unsigned long bytes,unsigned long lines,Boolean do32);
  178. static void AddOverParallel(UPtr Src,unsigned long srcinc,
  179.     UPtr Dst,unsigned long dstinc,
  180.     unsigned long bytes,unsigned long lines,Boolean do32);
  181. static void AddOver8(UPtr Src,unsigned long srcinc,
  182.     UPtr Dst,unsigned long dstinc,
  183.     unsigned long bytes,unsigned long lines,Boolean do32);
  184. static void MulOver8(UPtr Src,unsigned long srcinc,
  185.     UPtr Dst,unsigned long dstinc,
  186.     unsigned long bytes,unsigned long lines,Boolean do32);
  187.  
  188. int CopyBitsQuickly(BitMap *srcBits,BitMap *dstBits
  189.     ,Rect *srcRectPtr,Rect *dstRectPtr,long srcMode,RgnHandle maskRgn)
  190. {
  191.     UPtr Src,Dst;
  192.     long srcinc,dstinc;
  193.     unsigned long lines;
  194.     short srcRowBytes,dstRowBytes,srcPixelSize,dstPixelSize,srcBitsOffset,dstBitsOffset;
  195.     Rect mySrcRect,myDstRect;
  196.     int hOffset,vOffset;
  197.     double hMag,vMag;
  198.     long nudge,bytes;
  199.     Boolean do32,useBlockMove;
  200.     static Boolean can32,is32,wantBlockMove,firstTime=1;
  201.     long error,addressing,machine,processor;
  202.  
  203.     srcMode&=0xffff;    // upper bits are used only by CopyWindows.
  204.     if(srcMode != srcCopy && srcMode != addOver && srcMode != addOverParallel && srcMode != mulOver)
  205.         return 1;
  206.     if(maskRgn != NULL) return 2;
  207.  
  208.     /* clip the rect to be copied by the bounds of source and destination */
  209.     mySrcRect=*srcRectPtr;
  210.     myDstRect=*dstRectPtr;
  211.  
  212.     hMag=(double)(myDstRect.right-myDstRect.left)/(mySrcRect.right-mySrcRect.left);
  213.     vMag=(double)(myDstRect.bottom-myDstRect.top)/(mySrcRect.bottom-mySrcRect.top);
  214.     if((vMag!=1 || hMag!=1) && srcMode!=srcCopy)return 3;
  215.     /* first make sure that srcRect and dstRect are the same size */
  216. //    if(mySrcRect.bottom-mySrcRect.top != myDstRect.bottom-myDstRect.top || 
  217. //        mySrcRect.right-mySrcRect.left != myDstRect.right-myDstRect.left) 
  218. //            return 3;
  219.  
  220.     hOffset=myDstRect.left-mySrcRect.left*hMag;
  221.     vOffset=myDstRect.top-mySrcRect.top*vMag;
  222.     /* clip myDstRect */
  223.     Dst = RectToAddress((PixMap *)dstBits,&myDstRect,&dstRowBytes,&dstPixelSize,&dstBitsOffset);
  224.  
  225.     /*
  226.     This prevents writing outside the destination.
  227.     The cost is that part of the inside will not be written.
  228.     The problem arises because this routine's code can only write whole bytes,
  229.     and the boundary may be in the middle of a byte. So, rather than writing an
  230.     extra fraction of a byte (outside the destination rect) we leave the byte
  231.     alone and fail to update a small portion inside the destination rect.
  232.     */
  233.     if(dstBitsOffset>0) {
  234.         nudge=(7+dstBitsOffset)/8;
  235.         dstBitsOffset -= nudge*8;
  236.         Dst += nudge;
  237.         myDstRect.left += nudge*8/dstPixelSize;
  238.     }
  239.  
  240.     /* Copy any clipping of myDstRect over to mySrcRect */
  241.     mySrcRect=myDstRect;
  242.     ExpandAndOffsetRect(&mySrcRect,1/hMag,1/vMag,-hOffset/hMag,-vOffset/vMag);
  243.     /* clip mySrcRect */
  244.     Src=RectToAddress((PixMap *)srcBits,&mySrcRect
  245.         ,&srcRowBytes,&srcPixelSize,&srcBitsOffset);
  246.  
  247.     /* Copy any clipping of mySrcRect back to myDstRect */
  248.     myDstRect=mySrcRect;
  249.     ExpandAndOffsetRect(&myDstRect,hMag,vMag,hOffset,vOffset);
  250.     Dst=RectToAddress((PixMap *)dstBits,&myDstRect
  251.         ,&dstRowBytes,&dstPixelSize,&dstBitsOffset);
  252.  
  253.     if(Src==NULL || Dst==NULL) return 4;
  254.     if(srcPixelSize != dstPixelSize && srcMode!=srcCopy) return 5;
  255.     bytes = mySrcRect.right - mySrcRect.left;    /* number of pixels per line */
  256.     bytes *= srcPixelSize;                        /* number of bits per line */
  257.     bytes /= 8;                                    /* number of bytes per line */
  258.     srcinc = srcRowBytes - bytes;                /* offset in bytes to beginning of next line */
  259.     dstinc = dstRowBytes - bytes;
  260.     lines=mySrcRect.bottom - mySrcRect.top;        /* number of lines */
  261.     if(srcinc==0 && dstinc==0){
  262.         bytes*=lines;
  263.         lines=1;
  264.     }
  265.     if(firstTime){
  266.         can32=TrapAvailable(_SwapMMUMode);
  267.         addressing=0;
  268.         error=Gestalt(gestaltAddressingModeAttr,&addressing);
  269.         is32=addressing&(1L<<gestalt32BitAddressing);
  270.         // My tests indicate little or no advantage, even on PowerPC Macs.
  271.         wantBlockMove=0;
  272.         // Crude test for Rocket in Mac II.
  273.         // BlockMove to or from a video address crashes my Radius Rocket.
  274.         error=Gestalt(gestaltProcessorType,&processor);
  275.         error=Gestalt(gestaltMachineType,&machine);
  276.         if(machine==gestaltMacII && processor==gestalt68040)wantBlockMove=0;
  277.         firstTime=0;
  278.     }
  279.     // Must we switch to 32-bit addressing?
  280.     do32=(unsigned long)Src>0xffffffUL || (unsigned long)Dst>0xffffffUL;
  281.     do32=do32 && !is32;
  282.     if(do32 && !can32)return 6;
  283.     // Can't use traps if we switch 24/32-bit mode.
  284.     useBlockMove=wantBlockMove && !do32 && srcPixelSize==dstPixelSize;
  285.  
  286.     switch(srcMode){
  287.     case srcCopy:
  288.         if(hMag!=1 || vMag!=1 || srcPixelSize != dstPixelSize){
  289.             if(srcPixelSize==8 && dstPixelSize==8)Expand8(hMag,vMag,hOffset,vOffset
  290.                 ,Src,&mySrcRect,srcRowBytes,Dst,&myDstRect,dstRowBytes,do32);
  291.             else Expand(hMag,vMag,hOffset,vOffset
  292.                 ,Src,&mySrcRect,srcPixelSize,srcRowBytes
  293.                 ,Dst,&myDstRect,dstPixelSize,dstRowBytes,do32);
  294.         } else if(useBlockMove)SrcCopyQuickly2(Src,srcinc,Dst,dstinc,bytes,lines,do32);
  295.         else SrcCopyQuickly(Src,srcinc,Dst,dstinc,bytes,lines,do32);
  296.         break;
  297.     case addOverParallel:
  298.         if(srcPixelSize!=dstPixelSize)return 5;
  299.         AddOverParallel(Src,srcinc,Dst,dstinc,bytes,lines,do32);
  300.         break;
  301.     case addOver:
  302.         if(srcPixelSize!=8 || dstPixelSize!=8)return 7;
  303.         AddOver8(Src,srcinc,Dst,dstinc,bytes,lines,do32);
  304.         break;
  305.     case mulOver:
  306.         if(srcPixelSize!=8 || dstPixelSize!=8)return 7;
  307.         MulOver8(Src,srcinc,Dst,dstinc,bytes,lines,do32);
  308.         break;
  309.     default:
  310.         return 1;
  311.         break;
  312.     }
  313.     return 0;
  314. }
  315.  
  316. static void Expand8(double hMag,double vMag,double hOffset,double vOffset
  317.     ,register UPtr Src,Rect *srcRect,unsigned long srcRowBytes
  318.     ,register UPtr Dst,Rect *dstRect,unsigned long dstRowBytes,Boolean do32)
  319. {
  320.     int hh=round(hMag),vv=round(vMag);
  321.     int srcWidth,dstWidth;
  322.     register int i,j,ii;
  323.     register UPtr src,dst;
  324.     register unsigned char a;
  325.     signed char mmumode=true32b;
  326.  
  327.     hOffset;vOffset;dstRect;    /* unused arguments */
  328.     srcWidth=srcRect->right-srcRect->left;
  329.     dstWidth=srcWidth*hh;
  330.     for(j=srcRect->bottom-srcRect->top;j>0;j--){
  331.         src=Src;
  332.         dst=Dst;
  333.         if(do32)SwapMMUMode((void *)&mmumode);    /* set 32-bit mode */
  334.         for(i=srcWidth;i>0;i--){
  335.             a=*src++;
  336.             for(ii=hh;ii>0;ii--)*dst++=a;
  337.         }
  338.         if(do32)SwapMMUMode((void *)&mmumode);    /* set 32-bit mode */
  339.         src=Dst;
  340.         Dst+=dstRowBytes;
  341.         for(ii=vv-1;ii>0;ii--){
  342.             BlockMoveData(src,Dst,dstWidth);
  343.             Dst+=dstRowBytes;
  344.         }
  345.         Src+=srcRowBytes;
  346.     }
  347. }    
  348.  
  349. static void Expand(double hMag,double vMag,double hOffset,double vOffset
  350.     ,register UPtr Src,Rect *srcRect,int srcPixelBits,unsigned long srcRowBytes
  351.     ,register UPtr Dst,Rect *dstRect,int dstPixelBits,unsigned long dstRowBytes,Boolean do32)
  352. {
  353.     int hh=round(hMag),vv=round(vMag);
  354.     long srcWidth,dstWidth,bytes;
  355.     register int i,j,ii;
  356.     register UPtr src;
  357.     signed char mmumode=true32b;
  358.     unsigned long value[1024],v,*srcV,*dstV;
  359.  
  360.     hOffset;vOffset;dstRect;do32;    /* unused arguments */
  361.     srcWidth=srcRect->right-srcRect->left;
  362.     dstWidth=srcWidth*hh;
  363.     bytes=dstWidth*dstPixelBits/8;
  364.     for(j=srcRect->bottom-srcRect->top;j>0;j--){
  365.         ReadPixels(0,0,srcWidth,value,Src,srcPixelBits,srcRowBytes);
  366.         srcV=value+srcWidth-1;
  367.         dstV=value+srcWidth*hh-1;
  368.         for(i=srcWidth;i>0;i--){
  369.             v=*srcV--;
  370.             for(ii=hh;ii>0;ii--)*dstV--=v;
  371.         }
  372.         WritePixels(0,0,dstWidth,value,Dst,dstPixelBits,dstRowBytes);
  373.         src=Dst;
  374.         Dst+=dstRowBytes;
  375.         for(ii=vv-1;ii>0;ii--){
  376.             BlockMoveData(src,Dst,bytes);
  377.             Dst+=dstRowBytes;
  378.         }
  379.         Src+=srcRowBytes;
  380.     }
  381. }    
  382.  
  383. static void SrcCopyQuickly2(register UPtr Src,register unsigned long srcinc,
  384.     register UPtr Dst,register unsigned long dstinc,
  385.     unsigned long bytes,register unsigned long lines,Boolean do32)
  386. {
  387.     // See discussion of BlockMoveData at top of this file.
  388.  
  389.     do32;    /* dgp: prevent "unused argument" warning */
  390.     srcinc+=bytes;
  391.     dstinc+=bytes;
  392.     for(;lines>0;lines--){
  393.         BlockMoveData(Src,Dst,bytes);
  394.         Src+=srcinc;
  395.         Dst+=dstinc;
  396.     }
  397. }    
  398.  
  399. #define useMask 0
  400. static void SrcCopyQuickly(UPtr xSrc,register unsigned long srcinc,
  401.     UPtr xDst,register unsigned long dstinc,
  402.     register unsigned long bytes,register unsigned long lines,Boolean do32)
  403. {
  404.     register unsigned long *SrcL=(unsigned long *)xSrc,*DstL=(unsigned long *)xDst;
  405.     register long i;
  406.     signed char mmumode=true32b;
  407.     static unsigned long mask32[4]={0,0xff,0xffff,0xffffff};
  408.     register unsigned long m=mask32[bytes&3];
  409.  
  410.     if(useMask){
  411.         srcinc+=bytes&3;
  412.         dstinc+=bytes&3;
  413.     }
  414.     if(do32)SwapMMUMode((void *)&mmumode);    /* set 32-bit mode */
  415.     for(;lines>0;lines--) {
  416.         i=bytes>>7;
  417.         switch((bytes>>2)&31){
  418.             for(;i>=0;i--){
  419.                             *DstL++ = *SrcL++;
  420.                 case 31:    *DstL++ = *SrcL++;
  421.                 case 30:    *DstL++ = *SrcL++;
  422.                 case 29:    *DstL++ = *SrcL++;
  423.                 case 28:    *DstL++ = *SrcL++;
  424.                 case 27:    *DstL++ = *SrcL++;
  425.                 case 26:    *DstL++ = *SrcL++;
  426.                 case 25:    *DstL++ = *SrcL++;
  427.                 case 24:    *DstL++ = *SrcL++;
  428.                 case 23:    *DstL++ = *SrcL++;
  429.                 case 22:    *DstL++ = *SrcL++;
  430.                 case 21:    *DstL++ = *SrcL++;
  431.                 case 20:    *DstL++ = *SrcL++;
  432.                 case 19:    *DstL++ = *SrcL++;
  433.                 case 18:    *DstL++ = *SrcL++;
  434.                 case 17:    *DstL++ = *SrcL++;
  435.                 case 16:    *DstL++ = *SrcL++;
  436.                 case 15:    *DstL++ = *SrcL++;
  437.                 case 14:    *DstL++ = *SrcL++;
  438.                 case 13:    *DstL++ = *SrcL++;
  439.                 case 12:    *DstL++ = *SrcL++;
  440.                 case 11:    *DstL++ = *SrcL++;
  441.                 case 10:    *DstL++ = *SrcL++;
  442.                 case 9:        *DstL++ = *SrcL++;
  443.                 case 8:        *DstL++ = *SrcL++;
  444.                 case 7:        *DstL++ = *SrcL++;
  445.                 case 6:        *DstL++ = *SrcL++;
  446.                 case 5:        *DstL++ = *SrcL++;
  447.                 case 4:        *DstL++ = *SrcL++;
  448.                 case 3:        *DstL++ = *SrcL++;
  449.                 case 2:        *DstL++ = *SrcL++;
  450.                 case 1:        *DstL++ = *SrcL++;
  451.                 case 0:;
  452.             }
  453.         }
  454.         if(useMask){
  455.             if(m) *DstL=(m & *SrcL) | (!m & *DstL);
  456.         }else{
  457.             if(bytes&2){
  458.                 *(unsigned short *)DstL=*(unsigned short *)SrcL;
  459.                 DstL=(unsigned long *)(1+(unsigned short *)DstL);
  460.                 SrcL=(unsigned long *)(1+(unsigned short *)SrcL);
  461.             }
  462.             if(bytes&1){
  463.                 *(unsigned char *)DstL=*(unsigned char *)SrcL;
  464.                 DstL=(unsigned long *)(1+(unsigned char *)DstL);
  465.                 SrcL=(unsigned long *)(1+(unsigned char *)SrcL);
  466.             }
  467.         }
  468.         DstL=(unsigned long *)(dstinc+(unsigned char *)DstL);
  469.         SrcL=(unsigned long *)(srcinc+(unsigned char *)SrcL);
  470.     }
  471.     if(do32)SwapMMUMode((void *)&mmumode);    /* restore */
  472. }
  473.  
  474. static void AddOverParallel(UPtr xSrc,register unsigned long srcinc,
  475.     UPtr xDst,register unsigned long dstinc,
  476.     register unsigned long bytes,register unsigned long lines,Boolean do32)
  477. {
  478.     register unsigned long *SrcL=(unsigned long *)xSrc,*DstL=(unsigned long *)xDst;
  479.     register long i;
  480.     signed char mmumode;
  481.  
  482.     mmumode=true32b;
  483.     if(do32)SwapMMUMode((void *)&mmumode);    /* set 32-bit mode */
  484.     for(;lines>0;lines--) {
  485.         i=bytes>>7;
  486.         switch((bytes>>2)&31){
  487.             for(;i>=0;i--){
  488.                             *DstL++ += *SrcL++;
  489.                 case 31:    *DstL++ += *SrcL++;
  490.                 case 30:    *DstL++ += *SrcL++;
  491.                 case 29:    *DstL++ += *SrcL++;
  492.                 case 28:    *DstL++ += *SrcL++;
  493.                 case 27:    *DstL++ += *SrcL++;
  494.                 case 26:    *DstL++ += *SrcL++;
  495.                 case 25:    *DstL++ += *SrcL++;
  496.                 case 24:    *DstL++ += *SrcL++;
  497.                 case 23:    *DstL++ += *SrcL++;
  498.                 case 22:    *DstL++ += *SrcL++;
  499.                 case 21:    *DstL++ += *SrcL++;
  500.                 case 20:    *DstL++ += *SrcL++;
  501.                 case 19:    *DstL++ += *SrcL++;
  502.                 case 18:    *DstL++ += *SrcL++;
  503.                 case 17:    *DstL++ += *SrcL++;
  504.                 case 16:    *DstL++ += *SrcL++;
  505.                 case 15:    *DstL++ += *SrcL++;
  506.                 case 14:    *DstL++ += *SrcL++;
  507.                 case 13:    *DstL++ += *SrcL++;
  508.                 case 12:    *DstL++ += *SrcL++;
  509.                 case 11:    *DstL++ += *SrcL++;
  510.                 case 10:    *DstL++ += *SrcL++;
  511.                 case 9:        *DstL++ += *SrcL++;
  512.                 case 8:        *DstL++ += *SrcL++;
  513.                 case 7:        *DstL++ += *SrcL++;
  514.                 case 6:        *DstL++ += *SrcL++;
  515.                 case 5:        *DstL++ += *SrcL++;
  516.                 case 4:        *DstL++ += *SrcL++;
  517.                 case 3:        *DstL++ += *SrcL++;
  518.                 case 2:        *DstL++ += *SrcL++;
  519.                 case 1:        *DstL++ += *SrcL++;
  520.                 case 0:;
  521.             }
  522.         }
  523.         if(bytes&2){
  524.             *(unsigned short *)DstL += *(unsigned short *)SrcL;
  525.             DstL=(unsigned long *)(1+(unsigned short *)DstL);
  526.             SrcL=(unsigned long *)(1+(unsigned short *)SrcL);
  527.         }
  528.         if(bytes&1){
  529.             *(unsigned char *)DstL += *(unsigned char *)SrcL;
  530.             DstL=(unsigned long *)(1+(unsigned char *)DstL);
  531.             SrcL=(unsigned long *)(1+(unsigned char *)SrcL);
  532.         }
  533.         DstL=(unsigned long *)(dstinc+(unsigned char *)DstL);
  534.         SrcL=(unsigned long *)(srcinc+(unsigned char *)SrcL);
  535.     }
  536.     if(do32)SwapMMUMode((void *)&mmumode);    /* restore */
  537. }
  538.  
  539. static void AddOver8(register UPtr Src,register unsigned long srcinc,
  540.     register UPtr Dst,register unsigned long dstinc,
  541.     register unsigned long bytes,register unsigned long lines,Boolean do32)
  542. {
  543.     register long i;
  544.     signed char mmumode;
  545.  
  546.     mmumode=true32b;
  547.     if(do32)SwapMMUMode((void *)&mmumode);    /* set 32-bit mode */
  548.     for(;lines>0;lines--) {
  549.         i=bytes>>5;
  550.         switch(bytes&31){
  551.             for(;i>=0;i--){
  552.                             *Dst++ += *Src++;
  553.                 case 31:    *Dst++ += *Src++;
  554.                 case 30:    *Dst++ += *Src++;
  555.                 case 29:    *Dst++ += *Src++;
  556.                 case 28:    *Dst++ += *Src++;
  557.                 case 27:    *Dst++ += *Src++;
  558.                 case 26:    *Dst++ += *Src++;
  559.                 case 25:    *Dst++ += *Src++;
  560.                 case 24:    *Dst++ += *Src++;
  561.                 case 23:    *Dst++ += *Src++;
  562.                 case 22:    *Dst++ += *Src++;
  563.                 case 21:    *Dst++ += *Src++;
  564.                 case 20:    *Dst++ += *Src++;
  565.                 case 19:    *Dst++ += *Src++;
  566.                 case 18:    *Dst++ += *Src++;
  567.                 case 17:    *Dst++ += *Src++;
  568.                 case 16:    *Dst++ += *Src++;
  569.                 case 15:    *Dst++ += *Src++;
  570.                 case 14:    *Dst++ += *Src++;
  571.                 case 13:    *Dst++ += *Src++;
  572.                 case 12:    *Dst++ += *Src++;
  573.                 case 11:    *Dst++ += *Src++;
  574.                 case 10:    *Dst++ += *Src++;
  575.                 case 9:        *Dst++ += *Src++;
  576.                 case 8:        *Dst++ += *Src++;
  577.                 case 7:        *Dst++ += *Src++;
  578.                 case 6:        *Dst++ += *Src++;
  579.                 case 5:        *Dst++ += *Src++;
  580.                 case 4:        *Dst++ += *Src++;
  581.                 case 3:        *Dst++ += *Src++;
  582.                 case 2:        *Dst++ += *Src++;
  583.                 case 1:        *Dst++ += *Src++;
  584.                 case 0:;
  585.             }
  586.         }
  587.         Src += srcinc;
  588.         Dst += dstinc;
  589.     }
  590.     if(do32)SwapMMUMode((void *)&mmumode);    /* restore */
  591. }
  592.  
  593. // Multiply two unsigned 8-bit pixels, and divide the product by 128.
  594. static void MulOver8(register UPtr Src,register unsigned long srcinc,
  595.     register UPtr Dst,register unsigned long dstinc,
  596.     register unsigned long bytes,register unsigned long lines,Boolean do32)
  597. {
  598.     register long i;
  599.     signed char mmumode;
  600.  
  601.     mmumode=true32b;
  602.     if(do32)SwapMMUMode((void *)&mmumode);    /* set 32-bit mode */
  603.     for(;lines>0;lines--) {
  604.         i=bytes>>4;
  605.         switch(bytes&15){
  606.             for(;i>=0;i--){
  607.                             *Dst = ((unsigned short)(*Dst)*(*Src++))>>7; Dst++;
  608.                 case 15:    *Dst = ((unsigned short)(*Dst)*(*Src++))>>7; Dst++;
  609.                 case 14:    *Dst = ((unsigned short)(*Dst)*(*Src++))>>7; Dst++;
  610.                 case 13:    *Dst = ((unsigned short)(*Dst)*(*Src++))>>7; Dst++;
  611.                 case 12:    *Dst = ((unsigned short)(*Dst)*(*Src++))>>7; Dst++;
  612.                 case 11:    *Dst = ((unsigned short)(*Dst)*(*Src++))>>7; Dst++;
  613.                 case 10:    *Dst = ((unsigned short)(*Dst)*(*Src++))>>7; Dst++;
  614.                 case 9:        *Dst = ((unsigned short)(*Dst)*(*Src++))>>7; Dst++;
  615.                 case 8:        *Dst = ((unsigned short)(*Dst)*(*Src++))>>7; Dst++;
  616.                 case 7:        *Dst = ((unsigned short)(*Dst)*(*Src++))>>7; Dst++;
  617.                 case 6:        *Dst = ((unsigned short)(*Dst)*(*Src++))>>7; Dst++;
  618.                 case 5:        *Dst = ((unsigned short)(*Dst)*(*Src++))>>7; Dst++;
  619.                 case 4:        *Dst = ((unsigned short)(*Dst)*(*Src++))>>7; Dst++;
  620.                 case 3:        *Dst = ((unsigned short)(*Dst)*(*Src++))>>7; Dst++;
  621.                 case 2:        *Dst = ((unsigned short)(*Dst)*(*Src++))>>7; Dst++;
  622.                 case 1:        *Dst = ((unsigned short)(*Dst)*(*Src++))>>7; Dst++;
  623.                 case 0:;
  624.             }
  625.         }
  626.         Src += srcinc;
  627.         Dst += dstinc;
  628.     }
  629.     if(do32)SwapMMUMode((void *)&mmumode);    /* restore */
  630. }
  631.